package org.example.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.example.mapper.QuestionMapper;
import org.example.mapper.QuestionOptionMapper;
import org.example.mapper.QuestionnaireMapper;
import org.example.mapper.UserResponseMapper;
import org.example.model.Question;
import org.example.model.QuestionOption;
import org.example.model.Questionnaire;
import org.example.model.UserResponse;
import org.example.repository.QuestionnaireRepository;
import org.example.repository.UserResponseRepository;
import org.example.service.QuestionnaireService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class QuestionnaireServiceImpl implements QuestionnaireService {

    @Autowired
    private QuestionnaireRepository questionnaireRepository;

    @Autowired
    private UserResponseRepository userResponseRepository;
    
    // MyBatis-Plus Mapper
    @Autowired
    private QuestionnaireMapper questionnaireMapper;

    @Autowired
    private QuestionMapper questionMapper;
    
    @Autowired
    private QuestionOptionMapper questionOptionMapper;

    @Autowired
    private UserResponseMapper userResponseMapper;

    @Override
    @Transactional
    public Questionnaire createQuestionnaire(Questionnaire questionnaire) {
        // 设置创建时间和更新时间
        Date now = new Date();
        questionnaire.setCreateTime(now);
        questionnaire.setUpdateTime(now);
        questionnaire.setActive(true);
        
        // 设置默认创建者ID为1
        if (questionnaire.getCreatorId() == null) {
            questionnaire.setCreatorId(1L);
        }
        
        // 使用MyBatis-Plus保存问卷
        questionnaireMapper.insert(questionnaire);
        
        // 保存问题
        if (questionnaire.getQuestions() != null && !questionnaire.getQuestions().isEmpty()) {
            for (Question question : questionnaire.getQuestions()) {
                // 设置问卷ID
                question.setQuestionnaireId(questionnaire.getId());
                // 保存问题
                questionMapper.insert(question);
                
                // 保存选项
                if (question.getOptions() != null && !question.getOptions().isEmpty()) {
                    for (String optionText : question.getOptions()) {
                        QuestionOption option = new QuestionOption();
                        option.setQuestionId(question.getId());
                        option.setOptionText(optionText);
                        questionOptionMapper.insert(option);
                    }
                }
            }
        }
        
        return questionnaire;
    }

    @Override
    public List<Questionnaire> getAllQuestionnaires() {
        // 使用MyBatis-Plus获取所有活跃的问卷
        return questionnaireMapper.findByActiveTrue();
    }

    @Override
    public Questionnaire getQuestionnaireById(Long id) {
        // 使用MyBatis-Plus根据ID获取问卷
        Questionnaire questionnaire = questionnaireMapper.selectById(id);
        
        if (questionnaire != null) {
            // 查询问卷的所有问题
            List<Question> questions = questionMapper.findByQuestionnaireId(questionnaire.getId());
            
            // 为每个问题加载选项
            for (Question question : questions) {
                // 只有单选题和多选题需要加载选项
                if ("radio".equals(question.getType()) || "checkbox".equals(question.getType())) {
                    List<QuestionOption> options = questionOptionMapper.findByQuestionId(question.getId());
                    List<String> optionTexts = options.stream()
                            .map(QuestionOption::getOptionText)
                            .collect(Collectors.toList());
                    question.setOptions(optionTexts);
                }
            }
            
            questionnaire.setQuestions(questions);
        }
        
        return questionnaire;
    }

    @Override
    public UserResponse saveUserResponse(UserResponse userResponse) {
        // 设置提交时间
        userResponse.setSubmitTime(new Date());
        
        // 使用MyBatis-Plus保存用户回答
        userResponseMapper.insert(userResponse);
        return userResponse;
    }

    @Override
    public List<UserResponse> getUserResponses(Long userId) {
        // 使用MyBatis-Plus获取用户的所有回答
        LambdaQueryWrapper<UserResponse> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(UserResponse::getUserId, userId);
        return userResponseMapper.selectList(queryWrapper);
    }
} 